package com.android.allwinner.aw360;

import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.hardware.Camera;
import android.text.method.NumberKeyListener;
import android.util.Log;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * Created by xiasj on 17-6-9.
 * 360全景应用接口
 */

public class AW360API {

    private AW360Camera mAW360Camera;
    private Camera mCamera;
    private BirdViewListener mBirdViewListener;
    private Context mContext;
    private CommandReceiver mCommandReceiver;

    private AW360API() {
        mAW360Camera = new AW360Camera();
    }

    private static class SingletHolder {
        static final AW360API sInstance = new AW360API();
    }

    /**
     * 获取AW360API对象
     *
     * @return AW360API对象
     */
    public static AW360API getInstance() {
        return SingletHolder.sInstance;
    }

    /**
     * 初始化AW360API
     *
     * @param context 上下文环境
     * @param camera  360摄像头
     */
    public void init(Context context, Camera camera) {
        mAW360Camera = new AW360Camera();
        mAW360Camera.init(camera);
        mCamera = camera;
        mContext = context.getApplicationContext();
        mCommandReceiver = new CommandReceiver(mAW360Camera);
        IntentFilter intentFilter = new IntentFilter("android.aw360.test");
        mContext.registerReceiver(mCommandReceiver, intentFilter);
    }

    /**
     * 释放AW360API对象
     */
    public void release() {
        if (mAW360Camera != null) {
            mAW360Camera.release();
            mAW360Camera = null;
        }

        if (mCommandReceiver != null) {
            mContext.unregisterReceiver(mCommandReceiver);
            mCommandReceiver.releaseCamera();
            mCommandReceiver = null;
        }

    }

    /**
     * 设置镜头Sensor类型
     *
     * @param type 设置镜头Sensor类型。支持如下Sensor类型：
     *             {@link AW360Command#SENSOR_TYPE_1089_OR_3089}
     *             {@link AW360Command#SENSOR_TYPE_1099_OR_1058}
     * @return 设置结果，true：成功，false:失败。
     */
    public boolean setCameraSensorType(int type) {
        return mAW360Camera.setCameraSensorType(type);
    }

    /**
     * @param type 设置镜头类型。支持如下类型：
     *             {@link AW360Command#LENS_TYPE_HK8077}
     *             {@link AW360Command#LENS_TYPE_HAILIN4052}
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setCameraLensType(int type) {
        return mAW360Camera.setCameraLensType(type);
    }

    /**
     * 设置显示模式
     *
     * @param mode 显示模式。支持如下模式：
     *             {@link AW360Command#AW_DISPLAY_BIRDVIEW_FRONT}
     *             {@link AW360Command#AW_DISPLAY_BIRDVIEW_RIGHT}
     *             {@link AW360Command#AW_DISPLAY_BIRDVIEW_REAR}
     *             {@link AW360Command#AW_DISPLAY_BIRDVIEW_LEFT}
     *             {@link AW360Command#AW_DISPLAY_BIRDVIEW_ONLY}
     *             {@link AW360Command#AW_DISPLAY_SIDEVIEW_FRONT}
     *             {@link AW360Command#AW_DISPLAY_SIDEVIEW_REAR}
     *             {@link AW360Command#AW_DISPLAY_SIDEVIEW_RIGHT}
     *             {@link AW360Command#AW_DISPLAY_SIDEVIEW_LEFT}
     *             {@link AW360Command#AW_DISPLAY_SIDEVIEW_ALL}
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setViewModel(int mode) {
        return mAW360Camera.setCameraViewMode(mode);
    }

    /**
     * 设置摄像头制式
     *
     * @param standard 摄像头制式。支持如下摄像头制式：
     *                 {@link AW360Command#NTSC}
     *                 {@link AW360Command#PAL}
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setCameraStandard(int standard) {
        return mAW360Camera.setCameraStandard(standard);
    }

    /**
     * 设置车宽
     *
     * @param width 车宽（单位：毫米）
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setCarWidth(int width) {
        return mAW360Camera.setCarWidth(width);
    }

    /**
     * 设置车长
     *
     * @param height 车长（单位：毫米）
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setCarHeight(int height) {
        return mAW360Camera.setCarHeight(height);
    }

    /**
     * 设置左右偏移
     *
     * @param offset 左右偏移值（单位：毫米）
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setSideOffset(int offset) {
        return mAW360Camera.setCarSideOffset(offset);
    }

    /**
     * 设置前摄像头是否镜像
     *
     * @param isMirror 镜像: true,镜像；
     *                 false， 非镜像。
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setFrontCameraMirror(boolean isMirror) {
        if (isMirror) {
            return mAW360Camera.setFrontCameraMirror(AW360Command.CAMERA_MIRROR);
        } else {
            return mAW360Camera.setFrontCameraMirror(AW360Command.CAMERA_NORMAL);
        }
    }

    /**
     * 设置后摄像头是否镜像
     *
     * @param isMirror 镜像: true,镜像；
     *                 false， 非镜像。
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setRearCameraMirror(boolean isMirror) {
        if (isMirror) {
            return mAW360Camera.setRearCameraMirror(AW360Command.CAMERA_MIRROR);
        } else {
            return mAW360Camera.setRearCameraMirror(AW360Command.CAMERA_NORMAL);
        }
    }

    /**
     * 设置左摄像头是否镜像
     *
     * @param isMirror 镜像: true,镜像；
     *                 false， 非镜像。
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setLeftCameraMirror(boolean isMirror) {
        if (isMirror) {
            return mAW360Camera.setLeftCameraMirror(AW360Command.CAMERA_MIRROR);
        } else {
            return mAW360Camera.setLeftCameraMirror(AW360Command.CAMERA_NORMAL);
        }
    }

    /**
     * 设置左摄像头是否镜像
     *
     * @param isMirror 镜像: true,镜像；
     *                 false， 非镜像。
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setRightCameraMirror(boolean isMirror) {
        if (isMirror) {
            return mAW360Camera.setRightCameraMirror(AW360Command.CAMERA_MIRROR);
        } else {
            return mAW360Camera.setRightCameraMirror(AW360Command.CAMERA_NORMAL);
        }
    }

    /**
     * 设置前摄像头横向偏移值
     *
     * @param x 取值范围： -120~120。 超过范围返回false
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setFrontCameraOffsetX(int x) {
        return mAW360Camera.setFrontCameraOffsetX(x);
    }

    /**
     * 设置前摄像头纵向偏移值
     *
     * @param y 取值范围： -120~120。 超过范围返回false
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setFrontCameraOffsetY(int y) {
        return mAW360Camera.setFrontCameraOffsetY(y);
    }

    /**
     * 设置后摄像头横向偏移值
     *
     * @param x 取值范围： -120~120。 超过范围返回false
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setRearCameraOffsetX(int x) {
        return mAW360Camera.setRearCameraOffsetX(x);
    }

    /**
     * 设置后摄像头纵向偏移值
     *
     * @param y 取值范围： -120~120。 超过范围返回false
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setRearCameraOffsetY(int y) {
        return mAW360Camera.setRearCameraOffsetY(y);
    }

    /**
     * 设置左摄像头横向偏移值
     *
     * @param x 取值范围： -120~120。 超过范围返回false
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setLeftCameraOffsetX(int x) {
        return mAW360Camera.setLeftCameraOffsetX(x);
    }

    /**
     * 设置左摄像头纵向偏移值
     *
     * @param y 取值范围： -120~120。 超过范围返回false
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setLeftCameraOffsetY(int y) {
        return mAW360Camera.setLeftCameraOffsetY(y);
    }

    /**
     * 设置右摄像头横向偏移值
     *
     * @param x 取值范围： -120~120。 超过范围返回false
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setRightCameraOffsetX(int x) {
        return mAW360Camera.setRightCameraOffsetX(x);
    }

    /**
     * 设置右摄像头纵向偏移值
     *
     * @param y 取值范围： -120~120。 超过范围返回false
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setRightCameraOffsetY(int y) {
        return mAW360Camera.setRightCameraOffsetY(y);
    }

    /**
     * 设置前摄像头缩放
     *
     * @param scale 取值范围： 0.6~1.4。 超过范围返回false
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setFrontCameraScale(int scale) {
        return mAW360Camera.setFrontCameraScale(scale);
    }

    /**
     * 缩小前置摄像头视图
     *
     * @return 缩放结果 true:成功
     * false:失败
     */
    public boolean zoomInFrontCamera() {
        int scale = getFrontCameraScale();
        return setFrontCameraScale(scale + 1);
    }

    /**
     * 放大前置摄像头视图
     *
     * @return 缩放结果 true:成功
     * false:失败
     */
    public boolean zoomOutFrontCamera() {
        int scale = getFrontCameraScale();
        return setFrontCameraScale(scale - 1);
    }

    /**
     * 设置后摄像头缩放
     *
     * @param scale 取值范围： 0.6~1.4。 超过范围返回false
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setRearCameraScale(int scale) {
        return mAW360Camera.setRearCameraScale(scale);
    }

    /**
     * 缩小后置摄像头视图
     *
     * @return 缩放结果 true:成功
     * false:失败
     */
    public boolean zoomInRearCamera() {
        int scale = getRearCameraScale();
        return setRearCameraScale(scale + 1);
    }

    /**
     * 放大后置摄像头视图
     *
     * @return 缩放结果 true:成功
     * false:失败
     */
    public boolean zoomOutRearCamera() {
        int scale = getRearCameraScale();
        return setRearCameraScale(scale - 1);
    }

    /**
     * 设置左摄像头缩放
     *
     * @param scale 取值范围： 0.6~1.4。 超过范围返回false
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setLeftCameraScale(int scale) {
        return mAW360Camera.setLeftCameraScale(scale);
    }

    /**
     * 缩小左置摄像头视图
     *
     * @return 缩放结果 true:成功
     * false:失败
     */
    public boolean zoomInLeftCamera() {
        int scale = getLeftCameraScale();
        return setLeftCameraScale(scale + 1);
    }

    /**
     * 放大左置摄像头视图
     *
     * @return 缩放结果 true:成功
     * false:失败
     */
    public boolean zoomOutLeftCamera() {
        int scale = getLeftCameraScale();
        return setLeftCameraScale(scale - 1);
    }

    /**
     * 设置头缩放
     *
     * @param scale 取值范围： 0.6~1.4。 超过范围返回false
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setRightCameraScale(int scale) {
        return mAW360Camera.setRightCameraScale(scale);
    }

    /**
     * 缩小右置摄像头视图
     *
     * @return 缩放结果 true:成功
     * false:失败
     */
    public boolean zoomInRightCamera() {
        int scale = getRightCameraScale();
        return setRightCameraScale(scale + 1);
    }

    /**
     * 放大右置摄像头视图
     *
     * @return 缩放结果 true:成功
     * false:失败
     */
    public boolean zoomOutRightCamera() {
        int scale = getRightCameraScale();
        return setRightCameraScale(scale - 1);
    }

    /**
     * 设置是否显示倒车轨迹线
     *
     * @param show true: 显示
     *             false: 不显示
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setReverseRule(boolean show) {
        if (show) {
            return mAW360Camera.setReverseRule(AW360Command.REVERSE_RULE_SHOW);
        } else {
            return mAW360Camera.setReverseRule(AW360Command.REVERSE_RULE_MISS);
        }
    }

    /**
     * 设置摄像头亮度
     *
     * @param lum 亮度取值范围：0~255。超过范围返回false
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setCameraLum(int lum) {
        return mAW360Camera.setCameraLum(lum);
    }

    /**
     * 设置色度
     *
     * @param hue 色度取值范围：0~255。超过范围返回false
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setCameraHue(int hue) {
        return mAW360Camera.setCameraHue(hue);
    }

    /**
     * 设置对比度
     *
     * @param contrast 对度取值范围：0~255。超过范围返回false
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setCameraContrast(int contrast) {
        return mAW360Camera.setCameraContrast(contrast);
    }

    /**
     * 设置饱和度
     *
     * @param saturation 饱和取值范围：0~255。超过范围返回false
     * @return 设置结果，true:成功，false:失败。
     */
    public boolean setCameraSaturation(int saturation) {
        return mAW360Camera.setCameraSaturation(saturation);
    }

    /**
     * 获取摄像头Sensor类型
     * 默认值：
     * {@link AW360Command#SENSOR_TYPE_1089_OR_3089}
     *
     * @return 摄像头Sensor类型
     */
    public int getCameraSensorType() {
        return mAW360Camera.getCameraSensorType();
    }

    /**
     * 获取摄像头Lens类型
     * 默认值：
     * {@link AW360Command#LENS_TYPE_HK8077}
     *
     * @return 摄像头Lens类型
     */
    public int getCameraLensType() {
        return mAW360Camera.getCameraLensType();
    }

    /**
     * 获取全景显示类型
     * 默认值：
     * {@link AW360Command#AW_DISPLAY_BIRDVIEW_FRONT}
     *
     * @return 全景显示类型
     */
    public int getCameraViewMode() {
        return mAW360Camera.getCameraViewMode();
    }

    /**
     * 获取摄像头制式
     * 默认值：
     * {@link AW360Command#NTSC}
     *
     * @return 摄像头制式
     */
    public int getCameraStandard() {
        return mAW360Camera.getCameraStandard();
    }

    /**
     * 获取车宽
     *
     * @return 车宽
     */
    public int getCarWidth() {
        return mAW360Camera.getCarWidth();
    }

    /**
     * 获取车长
     *
     * @return 车长
     */
    public int getCarHeight() {
        return mAW360Camera.getCarHeight();
    }

    /**
     * 获取左右偏移值
     *
     * @return 左右偏移值
     */
    public int getCarSideOffset() {
        return mAW360Camera.getCarSideOffset();
    }

    /**
     * 获取前摄像头镜像
     *
     * @return 前摄像头镜像
     */
    public boolean getFrontCameraMirror() {
        return mAW360Camera.getFrontCameraMirror() == AW360Command.CAMERA_MIRROR;
    }

    /**
     * 获取后摄像头镜像
     *
     * @return 后摄像头镜像
     */
    public boolean getRearCameraMirror() {
        return mAW360Camera.getRearCameraMirror() == AW360Command.CAMERA_MIRROR;
    }

    /**
     * 获取左摄像头镜像
     *
     * @return 左摄像头镜像
     */
    public boolean getLeftCameraMirror() {
        return mAW360Camera.getLeftCameraMirror() == AW360Command.CAMERA_MIRROR;
    }

    /**
     * 获取右摄像头镜像
     *
     * @return 右摄像头镜像
     */
    public boolean getRightCameraMirror() {
        return mAW360Camera.getRightCameraMirror() == AW360Command.CAMERA_MIRROR;
    }

    /**
     * 获取前摄像头横向偏移
     *
     * @return 前摄像头纵向偏移值
     */
    public int getFrontCameraOffsetX() {
        return mAW360Camera.getFrontCameraOffsetX();
    }

    /**
     * 获取前摄像头横向偏移
     *
     * @return 前摄像头纵向偏移值
     */
    public int getFrontCameraOffsetY() {
        return mAW360Camera.getFrontCameraOffsetY();
    }

    /**
     * 获取后摄像头横向偏移
     *
     * @return 后摄像头纵向偏移值
     */
    public int getRearCameraOffsetX() {
        return mAW360Camera.getRearCameraOffsetX();
    }

    /**
     * 获取后摄像头横向偏移
     *
     * @return 后摄像头纵向偏移值
     */
    public int getRearCameraOffsetY() {
        return mAW360Camera.getRearCameraOffsetY();
    }

    /**
     * 获取左摄像头横向偏移
     *
     * @return 左摄像头纵向偏移值
     */
    public int getLeftCameraOffsetX() {
        return mAW360Camera.getLeftCameraOffsetX();
    }

    /**
     * 获取左摄像头横向偏移
     *
     * @return 左摄像头纵向偏移值
     */
    public int getLeftCameraOffsetY() {
        return mAW360Camera.getLeftCameraOffsetY();
    }

    /**
     * 获取右摄像头横向偏移
     *
     * @return 右摄像头纵向偏移值
     */
    public int getRightCameraOffsetX() {
        return mAW360Camera.getRightCameraOffsetX();
    }

    /**
     * 获取右摄像头横向偏移
     *
     * @return 右摄像头纵向偏移值
     */
    public int getRightCameraOffsetY() {
        return mAW360Camera.getRightCameraOffsetY();
    }


    /**
     * 获取前摄像头缩放比
     *
     * @return 前摄像头缩放比
     */
    public int getFrontCameraScale() {
        return mAW360Camera.getFrontCameraScale();
    }

    /**
     * 获取后摄像头缩放比
     *
     * @return 后摄像头缩放比
     */
    public int getRearCameraScale() {
        return mAW360Camera.getRearCameraScale();
    }

    /**
     * 获取左摄像头缩放比
     *
     * @return 左摄像头缩放比
     */
    public int getLeftCameraScale() {
        return mAW360Camera.getLeftCameraScale();
    }

    /**
     * 获取右摄像头缩放比
     *
     * @return 右摄像头缩放比
     */
    public int getRightCameraScale() {
        return mAW360Camera.getRightCameraScale();
    }

    /**
     * 获取显示亮度
     *
     * @return 亮度
     */
    public int getDisplayLum() {
        if (mAW360Camera == null) {
            return 0;
        }
        return mAW360Camera.getCameraLum();
    }

    /**
     * 获取显示色度
     *
     * @return 色度
     */
    public int getDisplayHue() {
        if (mAW360Camera == null) {
            return 0;
        }
        return mAW360Camera.getCameraHue();
    }

    /**
     * 获取显示对比度
     *
     * @return 对比度
     */
    public int getDisplayContrast() {
        if (mAW360Camera == null) {
            return 0;
        }
        return mAW360Camera.getCameraContrast();
    }

    /**
     * 获取显示饱和度
     *
     * @return 饱和度
     */
    public int getDisplaySaturation() {
        if (mAW360Camera == null) {
            return 0;
        }
        return mAW360Camera.getCameraSaturation();
    }

    /**
     * 获取全景和单路摄像头预览时的汽车图片位置
     *
     * @return 汽车图片位置
     */
    public CarPosition getMixCarPosition() {
        String position = mAW360Camera.getMixPosition();
        Log.i("AW360Camera", "position = " + position);
        CarPosition carPosition = new CarPosition();
        boolean result = carPosition.parsePosition(position);
        if (result) {
            return carPosition;
        }
        return null;
    }

    /**
     * 获取全景预览时的汽车图片位置
     *
     * @return 汽车图片位置
     */
    public CarPosition getBirdViewCarPosition() {
        String position = mAW360Camera.getBirdViewPosition();
        CarPosition carPosition = new CarPosition();
        boolean result = carPosition.parsePosition(position);
        if (result) {
            return carPosition;
        }
        return null;
    }

    /**
     * 镜头单路校正
     */
    public void cameraAdjust() {
        mAW360Camera.cameraAdjust();
    }

    /**
     * 全景校正
     */
    public void birdviewAdjust() {
        mAW360Camera.birdViewAdjust();
    }


    /**
     * 预览鸟瞰-前方模式
     */
    public void previewBFMode() {
        if (mAW360Camera == null) {
            return;
        }
        mAW360Camera.setCameraViewMode(AW360Command.AW_DISPLAY_BIRDVIEW_FRONT);
    }

    /**
     * 预览鸟瞰-后方模式
     */
    public void previewBBMode() {
        if (mAW360Camera == null) {
            return;
        }
        mAW360Camera.setCameraViewMode(AW360Command.AW_DISPLAY_BIRDVIEW_REAR);
    }

    /**
     * 预览鸟瞰-左方模式
     */
    public void previewBLMode() {
        if (mAW360Camera == null) {
            return;
        }
        mAW360Camera.setCameraViewMode(AW360Command.AW_DISPLAY_BIRDVIEW_LEFT);
    }

    /**
     * 预览鸟瞰-右方模式
     */
    public void previewBRMode() {
        if (mAW360Camera == null) {
            return;
        }
        mAW360Camera.setCameraViewMode(AW360Command.AW_DISPLAY_BIRDVIEW_RIGHT);
    }

    /**
     * 预览镜头-前方模式
     */
    public void previewCFMode() {
        if (mAW360Camera == null) {
            return;
        }
        mAW360Camera.setCameraViewMode(AW360Command.AW_DISPLAY_SIDEVIEW_FRONT);
    }

    /**
     * 预览镜头-后方模式
     */
    public void previewCBMode() {
        if (mAW360Camera == null) {
            return;
        }
        mAW360Camera.setCameraViewMode(AW360Command.AW_DISPLAY_SIDEVIEW_REAR);
    }

    /**
     * 预览镜头-左方模式
     */
    public void previewCLMode() {
        if (mAW360Camera == null) {
            return;
        }
        mAW360Camera.setCameraViewMode(AW360Command.AW_DISPLAY_SIDEVIEW_LEFT);
    }

    /**
     * 预览镜头-右方模式
     */
    public void previewCRMode() {
        if (mAW360Camera == null) {
            return;
        }
        mAW360Camera.setCameraViewMode(AW360Command.AW_DISPLAY_SIDEVIEW_RIGHT);
    }

    /**
     * 预览镜头-四路模式
     */
    public void previewCAMode() {
        if (mAW360Camera == null) {
            return;
        }
        mAW360Camera.setCameraViewMode(AW360Command.AW_DISPLAY_SIDEVIEW_ALL);
    }

    /**
     * 预览镜头-校正模式
     * 用于校正时
     */
    public void previewCalibrateMode() {
        if (mAW360Camera == null) {
            return;
        }
        mAW360Camera.setCameraViewMode(AW360Command.AW_DISPLAY_BIRDVIEW_ONLY);
    }

    /**
     * 设置屏幕宽度，用来计算汽车icon位置和全景的显示区域
     *
     * @param width 屏幕宽度 单位px
     */
    public void setScreenWidth(int width) {
        if (mAW360Camera == null) {
            return;
        }
        mAW360Camera.setScreenWidth(width);
    }

    /**
     * 设置屏幕高度，用来计算汽车icon位置和全景的显示区域
     *
     * @param height 屏幕高度  单位px
     */
    public void setScreenHeight(int height) {
        if (mAW360Camera == null) {
            return;
        }
        mAW360Camera.setScreenHeight(height);
    }

    /**
     * 设置录像模式。默认录制田字格四画面。
     *
     * @param mode
     */
    public void setRecorderMode(int mode) {
        if (mAW360Camera == null) {
            return;
        }
        mAW360Camera.setRecorderMode(mode);
    }

    /**
     * 设置校正数据导出路径
     * 默认为/sdcard/
     * 导出和导入数据的路径为同一个
     *
     * @param path
     */
    public void setExportPath(String path) {
        if (mAW360Camera == null) {
            return;
        }
        mAW360Camera.setExportPath(path);
    }

    /**
     * 获取导入数据的路径
     *
     * @return 导出路径
     */
    public String getExportPath() {
        if (mAW360Camera == null) {
            return "";
        }
        return mAW360Camera.getExportPath();
    }


    /**
     * 保存校正数据
     */
    public void save() {
        if (mAW360Camera == null) {
            return;
        }
        mAW360Camera.saveSettings();
    }

    /**
     * 导出校正数据到制定目录
     * 目录路径
     *
     * @param path 导出路径
     * @return 导出结果
     * @see #setExportPath(String)
     */
    public boolean exportData(String path) {
        if (mAW360Camera == null) {
            return false;
        }
        return mAW360Camera.exportData(path);
    }

    /**
     * 导入数据
     * 重新启动应用生效
     *
     * @param path 导入路径
     * @return 导入结果
     */
    public boolean importData(String path) {
        if (mAW360Camera == null) {
            return false;
        }
        return mAW360Camera.importData(path);
    }


    /**
     * 取消校正
     * 退出校正，返回之前保存的校正效果。
     */
    public void cancelCalibrate() {
        if (mAW360Camera == null) {
            return;
        }
        mAW360Camera.cancelCalibrate();
    }

    /**
     * 获取本地激活状态
     *
     * @return true: 已激活
     * false：未激活
     */
    public boolean getActivationStatus() {
        if (mAW360Camera == null) {
            return false;
        }
        return mAW360Camera.getActivationStatus();
    }

    /**
     * 可视范围调远
     * 如果没有效果，则已经调到最远效果
     */
    public void setViewRangeFar() {
        if (mAW360Camera == null) {
            return;
        }
        mAW360Camera.setViewRange(AW360Command.VIEW_RANGE_FAR);
    }

    /**
     * 可视范围调近
     * 如果没有效果，则已经调到最近效果
     */
    public void setViewRangeNear() {
        if (mAW360Camera == null) {
            return;
        }
        mAW360Camera.setViewRange(AW360Command.VIEW_RANGE_NEAR);
    }

    /**
     * 激活360全景
     *
     * @return false:未安装激活应用
     * true:开始激活
     */
    public boolean doActivate() {
        if (isAppInstalled(mContext, "com.allwinnertech.activator")) {
            Intent broadcast = new Intent(
                    "com.allwinnertech.android.activation.action.START_ACTIVATION");
            broadcast.putExtra("ACTIVATION_FUNCTION", "NEW_AW360");
            mContext.sendBroadcast(broadcast);
            return true;
        }

        return false;
    }


    private boolean isAppInstalled(Context context, String packagename) {
        PackageInfo packageInfo;
        try {
            packageInfo = context.getPackageManager().getPackageInfo(packagename, 0);
        } catch (PackageManager.NameNotFoundException e) {
            packageInfo = null;
            e.printStackTrace();
        }
        if (packageInfo == null) {
            return false;
        } else {
            return true;
        }
    }

    /**
     * 校正监听器
     * 反射底层的BirdViewCallbackListener接口
     */
    class CalibrateHandler implements InvocationHandler {

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Log.i("CalibrateHandler", "invoke method is " + method.getName());
            /**
             * BirdViewCallbackListener
             *
             */
            if ("onBirdViewCallbak".equals(method.getName())) {
                Log.i("CalibrateHandler", "onCalibrateDone");
                if (mBirdViewListener != null) {
                    mBirdViewListener.onCalibrateDone();
                }
            }
            return null;
        }
    }

    /**
     * 设置全景监听器
     *
     * @param listener
     * @see BirdViewListener
     */
    public void setBirdViewListener(BirdViewListener listener) {
        mBirdViewListener = listener;

        try {
            Class<?> mClass = Class.forName("android.hardware.Camera");
            Class<?> mListener = Class.forName("android.hardware.Camera$BirdViewCallbackListener");
            CalibrateHandler handler = new CalibrateHandler();
            Object mObj = Proxy.newProxyInstance(AW360API.class.getClassLoader(), new Class[]{mListener}, handler);
            Method mMethod = mClass.getDeclaredMethod("setBirdViewCallbackListener", new Class[]{mListener});
            mMethod.invoke(mCamera, new Object[]{mObj});
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    /**
     * 切换全景视图和单目视图的位置
     */
    public void exchangeDisplayView() {
        if (mAW360Camera == null) {
            return;
        }
        if (getDisplayViewModel() == AW360Command.SIDE_BIRD_VIEW_MODEL) {
            setDisplayViewModel(AW360Command.BIRD_SIDE_VIEW_MODEL);
        } else {
            setDisplayViewModel(AW360Command.SIDE_BIRD_VIEW_MODEL);
        }
    }

    /**
     * 设置全景视图和单目视图的位置模式
     *
     * @param model 模式
     * @see AW360Command#SIDE_BIRD_VIEW_MODEL
     * @see AW360Command#BIRD_SIDE_VIEW_MODEL
     */
    public void setDisplayViewModel(int model) {
        if (mAW360Camera == null) {
            return;
        }
        mAW360Camera.setDisplayViewModel(model);
    }

    /**
     * 获取全景视图和单目视图的位置模式
     *
     * @return 模式
     * @see #setDisplayViewModel(int)
     */
    public int getDisplayViewModel() {
        if (mAW360Camera == null) {
            return AW360Command.SIDE_BIRD_VIEW_MODEL;
        }
        return mAW360Camera.getDisplayViewModel();
    }

}
